Method and apparatus for handling directory operations

ABSTRACT

A method for handling a directory service operation includes determining whether an alternate evaluator can respond to the operation and evaluating the operation using the alternate evaluator when it is determined that the alternate evaluator can respond to the operation.

REFERENCE TO RELATED APPLICATION

The present application is based on provisional application Ser. No.60/573,512, filed May 21, 2004, the entire contents of which are hereinincorporated by reference.

BACKGROUND

1. Technical Field

The present disclosure relates to directory operations and, morespecifically, to a method and apparatus for handling directoryoperations.

2. Description of the Related Art

Directories are information services that provide users and applicationswith quick access to information. Directories are optimized forinformation retrieval. A directory server is a computer application thatprovides directory service to users and applications. One or moredirectory servers may be used to provide directory service to one ormore users and/or applications. By utilizing additional directoryservers, directory service may be simultaneously provided to a largenumber of users and/or applications. These directory servers may belocated together or they may be distributed. Directory servers may beglobally distributed and/or replicated to provide efficient directoryservice world-wide over a global computer network such as the internet.

X.500 is an international set of standards that defines directories.X.500 includes protocols for allowing users and applications to accessdirectory service. Other protocols may also be used for allowing usersand applications to access directory service. For example, LDAP, or theLightweight Directory Access Protocol, is a string based protocol.Another example is Directory Services Markup Language (DSML) which is avariant of Extensible Markup Language (XML).

Directory protocols usually utilize TCP/IP transfer services or similartransfer services. Directory protocols may also include internalsecurity features that may be useful for securing directory serviceaccess. Directory protocols are therefore well suited for providingaccess to directory service over the internet or private companyintranets.

Users and applications may utilize directory services to gain access toone or more data objects. The data objects may have one or moreattributes and the attributes may contain one or more values.

The hierarchical arrangement of directory information may provide forefficient searching. Hierarchical objects are commonly referred to asparent objects and child objects depending on their relationship to oneanother. For example, where a computer and a printer are represented asdata objects, an object representing a printer may be the child of anobject representing a computer.

The speed and efficiency of directories are important aspects of overalldirectory performance. Conventional methods for increasing directoryperformance involve increased use of hardware, software, or acombination of both hardware and software. For example, additional CPUs,disks, memory, directory server processes, etc. may be utilized in orderto improve response times, latency in a replicated environment, and/orthroughput or volume of operations, etc. However, while theseconventional methods do improve performance, they do so at a high costin terms of hardware, software, maintenance, and operations. Forexample, complex design and configuration, such as, routing, security,administrative controls, etc., may be involved in addition to complexmanagement of the system, including network, host administration,directory monitoring, distribution, replication, backup and recovery,etc.

Protocols for accessing directories define multiple operations that auser and/or application may perform. These operations may be categorizedinto three groups: queries, updates and connections. Queries areoperations for retrieving information from a directory. Query operationsinclude “read” for reading data, “list” for listing data, “search” forsearching for data and “compare” for comparing data. Update operationsinclude “add” for adding data, “remove” for deleting data, “modify” forchanging data and “ModifyDN” for changing the distinguished nameassociated with data, i.e. renaming data.

A query operation may include one or more sub-queries. For example, aquery may include a Navigation sub-query.

Conventional methods of handling operations in a directory typicallyrequire access to data generally stored in a non-volatile form, such ason a disk. Because the speed at which data may be accessed from disksand other non-volatile forms may be limited, caches may be used to speedup the retrieval of information. Caches are areas of memory, generallyvolatile memory, that are used to store previously accessed informationso that subsequent access attempts may be rapidly accessed from thecache without having to go back to the disk itself.

Caches are generally incremental caches, copying the most recentlyaccessed information from the disk to the cache. Caches improve accessspeed because commonly accessed information is likely to have beenplaced in the cache from the last time that information was accessed.Unfortunately, incremental caches may take time to load commonly usedinformation to the cache as information is only loaded into the cache asthat information is accessed from the disk. Additionally, because it isnot always clear when a cache is fully loaded or what types ofinformation are stored in the cache, it might not be possible toeffectively optimize operations such as queries for use with the cache.Additionally, if the sizes of the incremental caches are set too high,the stability of the caches may be reduced.

There are also time constraints associated with the incremental cache;for example, existing systems may handle at most only hundreds ofoperations per second. Customers of large organizations may demandgreater throughput and speed of operations. For example, a directoryoperation that is evaluated may involve many time-consuming steps, suchas, decoding the protocol, converting to SQL, interpreting the SQL,executing the SQL, handling by the disk cache buffers, and fetching thedata.

Even though cache memory may provide improvements in the speed ofdirectories, a cache typically operates as a buffer and has little, ifany, high level intelligence about the nature of directory operations.In addition, a cache may manage low-level data read/write operationswithout necessarily understanding what the data is.

Accordingly, it would be beneficial to provide a reliable and effectiveway to quickly and efficiently process directory operations.

SUMMARY

A method for handling a directory service operation includes determiningwhether an alternate evaluator can respond to the operation andevaluating the operation using the alternate evaluator when it isdetermined that the alternate evaluator can respond to the operation.

A system for handling a directory service operation includes a switchfor determining whether an alternate evaluator can respond to theoperation and the alternate evaluator for evaluating the operation whenit is determined that the alternate evaluator can respond to theoperation.

A computer system includes a processor and a computer recording mediumincluding computer executable code readable by the computer system. Therecording medium embodying a program of instructions executable by theprocessor for handling a directory service operation. The computerexecutable code includes determining whether an alternate evaluator canrespond to the operation and evaluating the operation using thealternate evaluator when it is determined that the alternate evaluatorcan respond to the operation.

A computer recording medium including computer executable code forhandling a directory service operation. The computer executable codeincludes determining whether an alternate evaluator can respond to theoperation and evaluating the operation using the alternate evaluatorwhen it is determined that the alternate evaluator can respond to theoperation.

A method of processing a Directory operation in a directory systemincludes a disk based evaluator and an alternate evaluator. The methodincludes the step of examining the query to determine if it can beprocessed by the alternate evaluator.

A directory system adapted to process directory queries. The systemincludes a disk based evaluator adapted to process directory queries inassociation with a data store. An alternate evaluator adapted to processdirectory queries in association with a local data store. Logic meansadapted to examine the query to determine if it can be processed by thealternate evaluator.

In a directory system adapted to process directory queries, the systemincludes a disk based evaluator adapted to process directory queries inassociation with a data store. An alternate evaluator adapted to processdirectory queries in association with a local data store. Theimprovement includes switch means adapted to examine the query todetermine if it can be processed by the alternate evaluator.

BRIEF DESCRIPTION OF THE DRAWINGS

A more complete appreciation of the present disclosure and many of theattendant advantages thereof will be readily obtained as the samebecomes better understood by reference to the following detaileddescription when considered in connection with the accompanyingdrawings, wherein:

FIG. 1 is a block diagram showing a system for processing directoryoperations;

FIG. 2 is a block diagram showing a system for processing directoryoperations using an alternate evaluator according to an embodiment ofthe present disclosure;

FIG. 3A is a block diagram showing a configuration with multipleswitches and multiple alternate evaluators according to an embodiment ofthe present disclosure;

FIG. 3B is a flow chart illustrating another embodiment of the presentinvention;

FIG. 4 is a flow chart showing a method for handling directoryoperations according to an embodiment of the present disclosure;

FIG. 5 is a block diagram showing an apparatus for a directory server;

FIG. 6 is a block diagram showing an apparatus for optimizing directoryperformance according to an embodiment of the present disclosure;

FIG. 7 is a block diagram showing another embodiment of the presentdisclosure;

FIG. 8 is a block diagram showing another embodiment of the presentdisclosure;

FIG. 9 is a flow chart showing an embodiment of the present disclosure;

FIG. 10 is a block diagram showing an apparatus for enhancing directoryperformance according to an embodiment of the present disclosure;

FIG. 11 is a flow chart showing a method for enhancing directoryperformance according to an embodiment of the present disclosure;

FIG. 12 is a flow chart illustrating a method for enhancing directoryperformance according to an embodiment of the present disclosure;

FIG. 13 shows an example of a computer system capable of implementingthe method and apparatus according to embodiments of the presentdisclosure;

FIG. 14 is a flow chart showing the loading of an alternative evaluatoraccording to an embodiment of the present disclosure;

FIG. 15 is a flow chart detailing the loading of an alternativeevaluator according to an embodiment of the present disclosure;

FIG. 16 is a flow chart showing an example of an update operationaccording to an embodiment of the present disclosure;

FIG. 17 is a flow chart showing another example of an update operationaccording to an embodiment of the present disclosure; and

FIG. 18 shows an example of a computer system which may implement themethod and system of the present disclosure.

DETAILED DESCRIPTION

The present disclosure provides tools (in the form of methodologies,apparatuses, and systems) for processing directory operations. The toolsmay be embodied in one or more computer programs stored on a computerreadable medium or program storage device and/or transmitted via acomputer network or other transmission medium.

In describing the preferred embodiments of the present disclosureillustrated in the drawings, specific terminology is employed for sakeof clarity. However, the present disclosure is not intended to belimited to the specific terminology so selected, and it is to beunderstood that each specific element includes all technical equivalentswhich operate in a similar manner.

FIG. 1 is a block diagram showing a system for processing directoryoperations. A directory operation, for example a query 101 may behandled by a directory server infrastructure 102, where the directoryserver 102 may utilize X.500 standards and X.500 protocols, LDAPprotocols and/or DSML protocols. The directory server infrastructure 102may have multiple processing layers 104-108 to execute the query 101.The processing layers 104-108 may be functional components of a server.For example, processing layers 104-108 may be used to decode protocolsused by the query, converting the query into standard protocols such asSQL, interpreting the SQL, executing the SQL, handling disk cachebuffers, and/or utilizing an operating system to retrieve data from adatabase 109. A response 110 to the query 101 may be generated byaccessing the database 109 that may be stored on one or more physicaldisks, for example a hard disk or a RAID array. One or more of theprocessing layers 106-108 may be located within a disk based evaluator103 that may be responsible for invoking one or more interactions withthe disk 109.

A query 101 may be passed from one processing layer 104-108 to anotheruntil a response 110 may be generated by accessing data on the disk 109.The response 110 may then be passed back along the processing layers104-108 allowing the response 110 to be delivered to the same locationand conforming to the same protocols as the query 101.

Each processing layer 104-108 may provide an important step in theprocessing of the query 101. For example, processing layers 104 and 105may be software for decoding protocols, authentication and/or routing.For example, processing layers 106, 107, and 108 may be software forchecking schema, controlling access and/or optimizing filters.

While the plurality of processing layers 104-108 may be useful forprocessing a query 101 to generate a response 110, having multiplelayers may increase the time required to respond to a query 101. It maytherefore be possible to lessen the time needed to process queries 101,in some instances, by reducing the number of processing layers 104-108required to process queries 101.

According to one embodiment of the present disclosure, an alternateevaluator may be used to lessen the time needed to process a query 101and generate a response 110. An alternate evaluator may be a directoryoperation processor that may be capable of processing directoryoperations. FIG. 2 is a block diagram showing a system for processingdirectory operations using an alternate evaluator according to anembodiment of the present disclosure.

According to this embodiment of the present disclosure, a switch 211 maybe provided at a point along the data path that connects the processinglayers 104-108. For example, the switch 211 may be placed before thefirst processing layer 104. The switch may examine an incomingoperation, for example a query 101 to determine whether an alternateevaluator 212 may be able to process the query 101 to generate aresponse 110. In making this determination, the switch 211 may rely onlocal configurations, for example, programmed logic that resides locallywithin the switch 211. For example, the switch 211 may be programmed toredirect some or all queries 101 that are search queries to thealternate evaluator 212 for processing.

The alternate evaluator 212 may then process the query 101 by accessinginformation stored on a local data store 213 that resides locally withinthe alternate evaluator 212. A response 110 may then be generated andreturned along the same data path that the query 101 was sent over. Inthis way, one or more processing layers 104-108 may be avoidedpotentially reducing the time required to process the query 101.

The local data store 213 may be persistent or non-persistent informationstore. In a preferred form, the local data store 213 uses local memory.

According to another embodiment of the present disclosure, thedetermination as to whether the alternate evaluator 212 may be able toprocess the query 101 may be made by the switch 211 in conjunction withthe alternate evaluator 212.

In determining whether the alternate evaluator 212 may be able toprocess the query 101, the switch 211 may be configured to categorizethe query 101 according to one or more known query types and/orrecognize the content of the query 101. If it is determined that thealternate evaluator 212 may not be able to process the query 101, theswitch 211 may allow the query 101 to proceed through the processinglayers 104-108 according to the data path rather than being diverted tothe alternate evaluator 212.

According to another embodiment of the present disclosure, the switch211 may allow a query 101 to proceed to the alternate evaluator 212 andto proceed through the processing layers 104-108 potentially allowingthe query to be evaluated in both ways. The processing of the query 101through the processing layers 104-108 may then later be discontinued ifthe alternate evaluator 212 is able to successfully process the query101.

According to one embodiment of the present disclosure, the alterativeevaluator 212 may reside within the directory server infrastructure 102.According to another embodiment of the present disclosure, the alternateevaluator 212 may reside outside of the directory server infrastructure102.

According to other embodiments of the present disclosure, there may beany number of switches 211 and/or alternate evaluators 212. FIG. 3A is ablock diagram showing a configuration with multiple switches 301-303 andmultiple alternate evaluators 304-306 according to an embodiment of thepresent disclosure.

One or more switches 301-303 may be provided at multiple points alongthe data path that connects the processing layers 104-106. According tosome embodiments of the present disclosure, one alternate evaluator304-306 may be provided for each switch 301-303. Alternatively, multipleswitches, for example switches 301 and 302, may each be capable ofredirecting a directory operation, for example a query 101 to the samealternate evaluator, for example 304. This may be beneficial insituations where a query 101 may be able to be handled by an alternateevaluator 304 either before being processed by one or more processinglayers, for example processing layer 104, or after being processed bythe one or more processing layers. Additionally, a single switch, forexample switch 303, may be able to redirect a query 101 to one of one ormore alternate evaluators, for example alternate evaluators 305 and 306.This may be useful when a switch determines that a query 101 may behandled by one alternate evaluator but not another. Each alternateevaluator 304-306 may have its own respective local data store 307-309or alternatively, one or more alternate evaluators 304-306 may share oneor more local data stores 307-309.

As a query 101 progresses down the data path, it may be progressivelyevaluated and/or transformed into a number of sub-queries. The alternateevaluators 304-306 may be able to process one or more queries 101, oneor more parts of a query 101, partly evaluated queries, and/orsub-queries.

FIG. 3B is a flow chart illustrating another embodiment of the presentinvention. A determination may be made as to whether to direct (forward)an operation, for example a query, to an alternate evaluator. A firsttest may be made to determine whether the alternate evaluator isavailable (Step S30). For example, if the alternate evaluator isenabled, busy or loading, the alternate evaluator would not beconsidered “available” (No, Step S30) and the query would not beforwarded to the alternate evaluator (Step S34).

If the alternate evaluator is available (Yes, Step S30), the firstparameter(s) are determined (Step S31) and the second parameter(s) aredetermined (Step S32). Examples of first parameters of the query whichare examined include its type, complexity, operands and properties, andthe attribute types including those required to process a query andthose needed to be returned. Examples of the second parameters includetype, complexity, operands and properties, and the attributes availableincluding those indexed and those carried (not indexed).

A test may be performed to determine if the first parameters aresupported by the second parameters (Step S33). If they are not supported(No, Step S33) then the query is not forwarded to the alternateevaluator (Step S34). If the first parameters are supported by thesecond parameters (Yes, Step S33), then a further test may be performedto determine if there are third (optional) parameters (Step S35).

Examples of third parameters include pre-determined criteria provided bythe user or system, arbitrary data provided by user, system policies,origin of query, user or user's role, operating conditions such as load,size limits and time limits. If there are no third parameters (No, StepS35), then the query may be forwarded to an alternate evaluator (StepS36). If there are third parameters (Yes, Step S35), then thirdparameters may be determined (Step S37).

A further test may be performed to determine if the third parametersrequire the query to be redirected in view of the third parameters (StepS38). If the query is not to be redirected (No, Step S38), then thequery is not forwarded to the alternate evaluator (Step S34).

If the third parameters allow redirection of the query, (Yes, Step S38)then a further test may be made to determine if the first parameters aresupported by the third parameters (Step S39). If they are not supported(No, Step S39), then the query is not directed to the alternateevaluator (Step S34). However, if the first parameters are supported bythe third parameters (Yes, Step S39), then the query may be forwarded tothe alternate evaluator (Step S36).

Example of the first parameters include: Operation type—For exampleoperation types are Read, Search, Compare, List, Add, Modify, etc.Operation complexity—For example of complexity would be a multi-termfilter. Operation operands—For example substring match, approximatematch, greater than or equal to match etc. Operation attribute(s)required to process a query—For example the attributes in a Searchfilter or the attribute in a Compare. Operation attribute(s) that needsto be returned—For example the attributes to return on a Search or Read.Service controls—For example size limit, time limit, prefer chaining,originator, attribute size limit, priority, other X.500 service controloptions. LDAP controls—for example proxied user, sorting, paging, eventmanagement. Network information—for example source address.

Examples of the second parameters include: Supported operation types—Forexample operation types are Read, Search, Compare, List, Add, Modify,etc. Supported operation complexity—For example of complexity would be amulti-term filter. Supported operation operands—For example substringmatch, approximate match, greater than or equal to match etc.Attribute(s) that are indexed. Attribute(s) that are carried (notindexed).

Examples of third parameters include: Arbitrary data provided by user.System policies. Origin of query. User or user's role. Operatingconditions such as load. Administrative thresholds—for example sizelimit, time limit, prefer chaining, security level, attribute sizelimit, priority or other physical limitations. Service options—forexample sorting, paging, event management, or other functionalabilities.

FIG. 4 is a flow chart showing a method for handling directoryoperations according to an embodiment of the present disclosure. Anoperation, for example a query may be received (Step S41). Next, it maybe determined whether the query may be processed using an alternateevaluator (Step S42). If the query may be so processed (Yes, Step S42),then the query may be redirected to the alternate evaluator (Step S43).The alternate evaluator may then evaluate the query using a local datastore (Step S44). If it is determined that the query cannot be processedby the alternate evaluator (No, Step S42), then the query may beevaluated using a disk-based database.

The combination of switches 211 and alternate evaluators 212 or adirectory service incorporating one or more switches and/or one or morealternate evaluators may be thought of more generally as an apparatusfor optimizing directory performance.

FIG. 5 is a block diagram showing an apparatus for optimizing directoryperformance. Directory operations, for example queries may originateform a location, for example from one or more query clients 52.Responses returned in response to the queries may be directed to thesame query client 52. Queries may be sent from the query client 52 to aserver 50. The server 50 may contain a first directory alternateevaluator, for example a front-end processor 53 that may managecommunications, queries and/or responses. The server 50 may also containa second directory alternate evaluator, for example a back-end processor54 that may manage the evaluation of operations, for example queries,using information stored on a disk 51.

The server 50 may provide a directory service. For example, the server50 may be a directory server conforming to implement directory X.500standards and one or more communications protocols, for example X.500protocols, LDAP protocols and DSML protocols.

FIG. 6 is a block diagram showing an apparatus for optimizing directoryperformance according to an embodiment of the present disclosure. Inthis embodiment, the server 50 may additionally contain an alternateevaluator 60. The alternate evaluator 60, may be provided between thefront-end processor 53 and the back-end processor 54 as shown in FIG. 6.

The alternate evaluator 60 may act as an alternate evaluator asdescribed above and may be able to generate a response for a receivedquery without having to send the query to the back-end processor 54.Queries that may be responded to by the alternate evaluator 60 may beresponded to more quickly than queries that may be responded to by theback-end processor 54 that uses the disk 51.

The alternate evaluator 60 may contain logic 61 and data 62. The logic61 may manage the evaluation of the queries. The logic 61 may use thedata 62 to evaluate the queries. The data 52 may be a local data storeas described above. The data 62 may be stored using a cache or a similarmemory store that may be faster than the disk 51.

The alternate evaluator 60 need not be located between the front-endprocessor 53 and the back-end processor 54. FIG. 7 is a block diagramshowing another embodiment of the present disclosure. Here the alternateevaluator 60 may be connected to the front-end processor 53 alone.According to this embodiment, the alternate evaluator 60 may be able toreceive and handle a query sent by the front-end processor 53.

FIG. 8 is a block diagram showing another embodiment of the presentdisclosure. Here the alternate evaluator 60 may be connected to theback-end processor 54. According to this embodiment, the alternateevaluator 60 may be able to receive and handle a query sent by theback-end processor.

The front-end processor 53, the alternate evaluator 60, and the back-endprocessor 54 need not be located on the same server 50. According toanother embodiment of the present disclosure, each of the front-endprocessor 53, the alternate evaluator 60, and the back-end processor 54may be provided as a separate server, wherein each of the servers may beinterconnected. According to another embodiment of the presentdisclosure, any two of the front-end processor 53, the alternateevaluator 60, and the back-end processor 54 may be provided on a firstserver while the other may be provided on a second server, wherein eachof the servers may be interconnected.

FIG. 9 is a flow chart showing an embodiment of the present disclosure.A directory operation, for example a query may be received, for example,from a client, by a front-end processor (Step S91). An alternateevaluator may attempt to evaluate the query using data in the alternateevaluator, for example, data stored in a cache (Step S92). If theevaluation is successful (Yes, Step S93) then a response to the querymay be returned to the query client. If the evaluation is not successful(No, Step S93) then the query may be passed to a back-end processor(Step S94). The back-end processor may evaluate the query using a disk(Step S95). A response to the query may thereby be returned to the queryclient.

The alternate evaluator's data (local data store) may be a cache ofrandom access memory (RAM). According to embodiments of the presentdisclosure, the alternate evaluator may be preloaded with selectedinformation from the disk or disk's conventional cache (a cacheassociated with the disk as opposed to the local data store that isassociated with the alternate evaluator) prior to the use of thealternate evaluator. The preloading of the alternate evaluator may allowthe alternate evaluator to evaluate the query without having to accessthe disk.

An apparatus for enhancing directory server performance, according toone embodiment of the present disclosure, will be discussed withreference to FIG. 10. The apparatus 120 includes a determining means121, retrieving means 122, normalizing means 123 and indexing means 124.

A method for enhancing directory server performance will be explainedbelow with reference to FIGS. 10 and 11. The determining means 121 maydetermine one or more data types from the disk or disk cache (storage)to be loaded into the alternate evaluator (Step S131). The retrievingmeans 122 may retrieve data from the storage based on the determineddata types (Step S132). The normalizing means 123 may determine andnormalize one or more index values for the data retrieved by theretrieving means 122 (Step S133). The indexing means 124 may load analternate evaluator with the retrieved data and the normalized indexvalues (Step S134). In one embodiment, any of the determining means 121,retrieving means 122, normalizing means 123 or indexing means 124 may bebased on control variables 150 (FIG. 13).

By preloading the alternate evaluator, the alternate evaluator or otherlogic may be able to determine if the alternate evaluator can process agiven query without having to access the disk storage. Additionally, bypreloading the alternate evaluator, the alternate evaluator may be ableto achieve maximum performance on startup, unlike conventional cachesthat may require time to warm up.

According to an embodiment of the present disclosure, selectedinformation may be preloaded into the alternate evaluator from storagebefore a query is handled by the system. Storage may include a physicaldisk, disk cache, memory, or any other means of storing data. Theprocess of pre-loading may include, for example, extracting fromstorage, such as a disk, selected information which can be indexed bythe alternate evaluator. The selected information may be determined by aconfiguration as defined in the alternate evaluator. For example, index“CommonName” and carry “Surname” and “TelephoneNumber” may be providedin the configuration. It should be noted that “carry” means that certaininformation may be stored in an alternate evaluator, but may not beindexed. The index values may be normalized, or transformed into astandard form according to matching rules for the data type. Forexample, a “case-ignore” matching rule would convert the data types intoone case. The selected information may be in a raw format, or stored ina binary encoded form, such as Abstract Syntax Notation 1 (ASN.1).

According to an embodiment of the present disclosure, if the selectedinformation is already loaded in the alternate evaluator, a pointer tothe existing value may be added to the alternate evaluator rather thanadding the selected information to the alternate evaluator multipletimes.

FIG. 12 is a flow chart illustrating a method for enhancing directoryperformance according to an embodiment of the present disclosure. Aftera directory server is started up or re-initialized (Step S141), theconfiguration of the alternate evaluator may be read (Step S142). Theconfiguration may specify the attribute types to be loaded, or mayspecify that all attribute types are to be loaded. The configuration mayalso specify whether each attribute type is indexed. Based on theconfiguration, the appropriate data may be retrieved from storage (StepS143). The retrieved data may include at least one directory object,where each object may include one or more attributes, and where eachattribute may include one or more values. For each data value retrieved,it may be determined whether the data is already loaded in the alternateevaluator (Step S144). If the data is already loaded in the alternateevaluator (Yes, Step S144), then the duplicate data may be determinedand a pointer may be provided to the existing value in the alternateevaluator (Step S145). If the data is not already loaded in thealternate evaluator (No, Step S144), then the index values for the dataare determined (Step S146) provided that the data values are indexed(based on the configuration), and the index values are normalized (StepS147). For example, the normalized index values may be stored as astructured index, such as, a BTREE, BTREE+, and/or any other indexingstructures. The alternate evaluator may then be loaded with the datavalues and the normalized index values (Step S148). In anotherembodiment, the indexes may be determined dynamically upon loading ofthe alternate evaluator. In a further embodiment, the indexes may bedetermined in accordance with control variables.

A BTREE is a tree data structure that may be used by databases andindexes to facilitate searching. BTREEs allow for amortized logarithmictime insertions and deletions of tree elements.

According to an embodiment of the present disclosure, the alternateevaluator may be loaded with all the data values and the index values ina single pass. According to another embodiment of the presentdisclosure, the alternate evaluator may be loaded with the data valuesin one step and loaded with the index values in another step.

As described above, the alternate evaluator, for example a local datastore within an alternate evaluator, may comprise a memory store.According to some embodiments of the present disclosure, the alternateevaluator may be pre-loaded and progressively updated to enhance thealternate evaluator's ability to quickly and accurately handle directoryoperations, for example queries.

After the alternate evaluator is preloaded, the alternate evaluator mayreceive progressive updates to maintain accuracy of stored data,efficiency of memory storage and speed of evaluation. For example, datastructures may be retrieved from storage and used to progressivelyupdate data stored in the alternate evaluator. In so doing, embodimentsof the present disclosure may be able to facilitate the storage of ahigh occupancy of indexes, minimize the number of comparisons requiredto execute a query and to provide multiple index types, such as, forexample, reverse indexes.

In determining what data to pre-load and/or progressively update,control variables may be considered. Additionally, the type ofattributes that are indexed may be considered. Control variables maydescribe, for example, whether an alternate evaluator is available, whatindexes are in effect, what attributes are stored, and/or the maximumamount of alternate evaluator memory available. For example, entriesand/or attributes relating to one or more attribute indexes may beloaded and/or progressively updated to the alternate evaluator. It mayalso be possible to load and/or progressively update all entries and/orattributes, for example, where a configuration of indexed attributes isset to “all attributes.”

In loading and/or progressively updating the alternate evaluator, theeffectiveness of the alternate evaluator may be maximized by using theavailable alternate evaluator memory as efficiently as possible.Embodiments of the present disclosure may utilize one or more methodsfor efficiently utilizing alternate evaluator memory. For example, wheredata is repeated in multiple locations of the alternate evaluatormemory, the instances of that data may be replaced with a pointer. Forexample, attribute type data may be replaced with a pointer that pointsto an attribute type store where attribute type data is stored. Forexample, where data utilizes names that are comprised of a contextprefix (the distinguished name of a root entry) and a relative name, thecontext prefix may be removed from the name to reduce the amount ofmemory required to store the names. For example, an available memorylist may be maintained to keep track of available memory so that memorythat was previously used may be quickly identifiable as free memory. Forexample, a list of normalized values may be maintained for attributevalues that are indexed so that multiple units of data do not need toindividually store normalized values for the same sets of values.Normalized values may be created from attribute values that areconfigured as indexed attributes.

According to embodiments of the present disclosure, data stored in thealternate evaluator need not be updated every time the data in storage(external data source), upon which the data stored in the alternateevaluator was loaded from, is updated. For example, where stored and/orindexed attributers from a list of entries comprising attributes andattribute values is stored in the alternate evaluator, the stored and/orindexed attributes may only be updated when those stored and/or indexedattributers are modified on the list of entries and may not be updatedwhen the list is modified but the stored and/or indexed attributesremain unchanged.

FIG. 13 is a block diagram showing an alternate evaluator according toan embodiment of the present disclosure. Directory operations, forexample queries may be directed towards the alternate evaluator 151 overa data path for receiving operations 153. Each query directed towardsthe alternate evaluator 151 may result in a response. The response maybe sent along a data path for providing results 154. Data loaded intothe alternate evaluator 151, may be organized into one or more lists155-159 within an arrangement of memory included within the alternateevaluator. The lists 155-159 may represent data structures for thestoring of data entries, attributes, attribute vales, normalized values,indexes, available memory, etc. Control variables may be entered intothe alternate evaluator 151 and stored within a portion of memoryprovided to store control variables 150. Control variables 150 may beused to define a set of controls, for example, to define what data is tobe stored from an external data store 152 to the one or more lists155-159. For example, to determine what indexes are in effect and/or todetermine the maximum amount of available memory

The control variables 150 may be used, for example, to define attributesto be indexed. For example, the control variables 150 may define thatall attributes be indexed by setting an indexed attribute controlvariable to “all attributes.” Similarly, the control variables 150 maydefine attributes to be stored. For example, the control variables 150may define that all attributes be stored by setting a stored attributecontrol variable to “all attributes.”

The control variables 150 may be used, for example, to define entries tobe loaded into the alternate evaluator 151 from the external data store152. For example, the control variables 150 may define that all entriesshould be loaded by setting the indexed attribute control variable to“all entries.” Alternatively, the indexed attribute control variable maybe set to a list of attributes. In such a case only those attributespresent in the list may be loaded.

The control variables 150 may be used, for example, to define attributesto be loaded with each entry. For example, where either the indexedattribute control variable or the stored attribute control variable isset to “all attributes” then all attributes within each entry may beloaded. For example, where both the indexed attribute control variableand the stored attribute control variable are set to a list ofattributes, then the attributes loaded within each entry may be acombination of both lists.

A configuration function (not shown) may be provided to set the controlvariables.

An alternate evaluator 151 according to an embodiment of the presentdisclosure may have a first list 155. Data may be first loaded into thefirst list 155 via a data path 160 from a disk 152 and/or directory 161.The first list 155 may comprise one or more entries. Each entry may havea name and/or one or more attributes. Each attribute may have a typeand/or one or more values. For example, the entries may be directoryentries. The name may be a distinguished name for the directory entry.The attributes may be directory attributes. The types may be objectidentifiers or strings, either of which may represent the types of theattributes. The values may be the values of the attributes and may bestored in binary form.

To reduce memory requirements, entries that are loaded into thealternate evaluator 151 may have the context prefix removed from theirdistinguished name.

The alternate evaluator 151 may have a second list 156. The second list156 may be loaded with normalized values of data that has been loadedinto the first list 155. The normalized values may be representations ofthe values in a predetermined format, for example in the internationallydefined X.500 matching format. Normalizing values may allow forcomparison regardless of the format of the values. For example, where aCommonName attribute for an entry is “Rick Harvey” a CaselgnoreStringmatching rule may be used to create the normalized value “RICK HARVEY”where the CaseIgnoreString matching rule is defined as removing leadingand trailing spaces, replacing multiple consecutive spaces with a singlespace and converting the string into upper case. The second list 156 mayadditionally be loaded with pointers that point to the correspondingdata that has been loaded into the first list 155. The indexed attributecontrol variable may determine what normalized data and pointers may beloaded into the second list 156.

The alternate evaluator 151 may have a third list 157. The third list157 may be loaded with indexes and pointers to the normalized valuesthat have been loaded into the second list 156. For example, the thirdlist 157 may have at least one index that is organized as a BTREE.

The alternate evaluator 151 may have a fourth list 158. The fourth list158 may be a list of available memory locations. For example, the fourthlist may list one or more memory fragments not currently used by thealternate evaluator. The fourth list 158 may be initially empty. Thefourth list may be updated during the operation of the alternateevaluator as memory fragments are used and become available (returned toan unused state).

The alternate evaluator 151 may have a context prefix store (not shown).The context prefix store may be used to store the context prefix of datanames, for example, entry names. The context prefix store may store anormalized value of the content prefix. The context prefix store may beassociated with the data path for receiving operations 153 and/or thedata path for providing results 154

The alternate evaluator 151 may have a fifth list 159. The fifth list159 may be a list of types, for example, attribute types, that occur oneor more times in the first list 155. Types may take the form of anobject identifier or a string. The first list 155 may replace instancesof attribute types stored in the fifth list 159 with pointers that pointto the same attribute type in the fifth list 159. By utilizing thesepointers to the fifth list 159, available memory may be saved byreducing the number of times the same attribute type is stored.

FIG. 14 is a flow chart showing the loading of a list according to anembodiment of the present disclosure. Control variables may be retrieved(Step S162). The retrieved control variables may then be used todetermine data to be loaded from the external data store (Step S163).The context prefixes from distinguished names may be removed from thedetermined data (Step S164). The determined data may then be loaded intothe alternate evaluator and/or a list, for example a list within analternate evaluator (Step S165).

FIG. 15 is a flow chart detailing the loading of lists, such any of thelists in an alternate evaluator according to an embodiment of thepresent disclosure. First the first list may be loaded, for example, thefirst list may be loaded based on inputted control variables (StepS171). Next the second list may be loaded, for example, based on thefirst list (Step S172). Next the third list may be loaded, for example,based on the second list (Step S173). The fourth list may be used tostore items removed from any of the other lists during operation. Nextthe fifth list may be loaded, for example, based on the first list (StepS174). Loading of the lists may be executed, for example, in the fashiondescribed above.

As described above, as data within the external data store is changed,it may be beneficial to perform an update operation to update theinformation within the alternate evaluator and/or lists. Because thelists may be interdependent, updating the first list may often befollowed by updating subsequent lists as necessary to maintain the datastructure of the alternate evaluator. The update operation may include,for example, one or more of the following: Adding an entry with a nameand/or a set of attributes, each attribute containing one or moreattribute values. Removing an entry including any of its associatednames, attributes and/or attribute values. Modifying an entry to addand/or remove an attribute and/or attribute values. Rename an entry tochange an entry's name by adding, removing or selecting existingattribute values.

FIG. 16 is a flow chart showing an example of an update operationaccording to an embodiment of the present disclosure. For example, theupdate operation may involve adding data, for example, entries,attributes and/or attribute values, to the first list. For example,added data may be indexed attributes or stored attributes. Prior toadding the data, context prefixes may be removed from names within thedata (Step 181). Prior to adding the data, attribute types within thedata may be replaced with pointers that point to the same attribute typein the fifth list (Step S182). Where the attribute type is not alreadypresent in the fifth list (No, Step S183), it may be added to the fifthlist (Step S184). Next, the data may be added to the first list withinavailable memory that may be determined using the fourth list (StepS185). Available memory may then be updated within the fourth list basedon the memory used in storing the data (Step S186).

It may be advantageous to have normalized values for the data presentwithin the second list. This may be especially true where the data is anindexed attribute. Where it may be so advantageous, the second list maybe checked to see if it contains normalized values of the data (StepS187). Where it does not (No, Step S187), normalized values may be addedto the second list and a pointer to the data is added to the normalizedvalues in the second list (Step S188). In adding to the second list,available memory may be ascertained from the fourth list and memory usedmay be reflected in the fourth list, for example, by removing the usedmemory from the fourth list. Additions made to the second list may bereflected within the index and pointers of the third list (Step S189).For example, a pointer may be added to the index.

FIG. 17 is a flow chart showing another example of an update operationaccording to an embodiment of the present disclosure. For example, theupdate operation may involve removing data, for example, entries,attributes and/or attribute values, to the first list. First the datamay be removed from the first list (Step S191). If the removed data ispointed to by a pointer in the second list corresponding to normalizedvalues for the data, the corresponding pointers may be removed from thesecond list (Step S192). When the last pointer of a normalized value inthe second list is removed (Yes, Step S193), the normalized value may beremoved and the corresponding pointer may be removed from the index onthe third list (Step S194). The fourth list may then be updated toreflect that the memory used by deleted elements is available memory(Step S195).

According to embodiments of the present disclosure, the lists may be ofany length. According to embodiments of the present disclosure, thelists may be dynamic in size and content, for example, during theoperation of the alternate evaluator. According to embodiments of thepresent disclosure, the lists may be linked lists and/or arrays.

Numerous additional modifications and variations of the presentdisclosure are possible in view of the above-teachings. It may thereforebe understood that within the scope of the appended claims, the presentdisclosure may be practiced other than as specifically described herein.

FIG. 18 shows an example of a computer system which may implement themethod and system of the present disclosure. The system and method ofthe present disclosure may be implemented in the form of a softwareapplication running on a computer system, for example, a mainframe,personal computer (PC), handheld computer, server, etc. The softwareapplication may be stored on a recording media locally accessible by thecomputer system and accessible via a hard wired or wireless connectionto a network, for example, a local area network, or the Internet.

The computer system referred to generally as system 1000 may include,for example, a central processing unit (CPU) 1001, random access memory(RAM) 1004, a printer interface 1010, a display unit 1011, a local areanetwork (LAN) data transmission controller 1005, a LAN interface 1006, anetwork controller 1003, an internal bus 1002, and one or more inputdevices 1009, for example, a keyboard, mouse etc. As shown, the system1000 may be connected to a data storage device, for example, a harddisk, 1008 via a link 1007.

The above specific embodiments are illustrative, and many variations canbe introduced on these embodiments without departing from the spirit ofthe disclosure or from the scope of the appended claims. For example,elements and/or features of different illustrative embodiments may becombined with each other and/or substituted for each other within thescope of this disclosure and appended claims.

1. A method for handling a directory service operation, comprising:determining whether an alternate evaluator can respond to the operation;and evaluating the operation using the alternate evaluator when it isdetermined that the alternate evaluator can respond to the operation. 2.The method of claim 1, wherein the directory service operation ishandled by a directory service conforming to X.500 standards.
 3. Themethod of claim 2, wherein the directory service utilizes DSMLcommunications protocols.
 4. The method of claim 2, wherein thedirectory service utilizes LDAP communications protocols.
 5. The methodof claim 1, wherein the directory service operation is a query.
 6. Themethod of claim 5, wherein the query is any directory query.
 7. Themethod of claim 5, wherein the query is any directory sub-query such asNavigation.
 8. The method of claim 1, wherein determining whether analternate evaluator can respond to the operation is based on content ofthe operation.
 9. The method of claim 1, wherein evaluating theoperation using the alternate evaluator comprises generating a responseto the operation.
 10. The method of claim 1, further comprisingevaluating the operation using a primary evaluator when it is determinedthat the alternate evaluator cannot respond to the operation.
 11. Themethod of claim 10, wherein evaluating the operation using the primaryevaluator comprises generating a response to the operation.
 12. Themethod of claim 10, wherein the primary evaluator accesses informationstored on a disk in evaluating the operation.
 13. The method of claim 1,wherein a switch is used in determining whether the alternate evaluatorcan respond to the operation.
 14. The method of claim 13, wherein theswitch uses local configurations to determine whether the alternateevaluator can respond to the operation.
 15. The method of claim 13,wherein the switch uses the alternate evaluator to determine whether thealternate evaluator can respond to the operation.
 16. The method ofclaim 1, wherein logic is used in determining whether the alternateevaluator can respond to the operation.
 17. The method of claim 1,wherein evaluating the operation using the alternate evaluator is fasterthan evaluating the operation using a primary evaluator.
 18. The methodof claim 1, wherein evaluating the operation using the alternateevaluator involves fewer processing layers than evaluating the operationusing a primary evaluator.
 19. The method of claim 1, wherein thealternate evaluator evaluates the operation using data that is storedlocally to the alternate evaluator.
 20. The method of claim 19, whereinthe data that is stored locally comprises a local data store.
 21. Themethod of claim 1, wherein determining whether the alternate evaluatorcan respond to the operation comprises categorizing the operationaccording to one or more known operation types.
 22. The method of claim1, wherein determining whether the alternate evaluator can respond tothe operation comprises recognizing content of the operation.
 23. Themethod of claim 1, wherein two or more alternate evaluators are used toevaluate one or more operations at various stages of a data path ofprocessing layers.
 24. The method of claim 23, wherein one or moreswitches are used in determining whether the two or more alternateevaluator can respond to the operations.
 25. A system for handling adirectory service operation, comprising: a switch for determiningwhether an alternate evaluator can respond to the operation; and thealternate evaluator for evaluating the operation when it is determinedthat the alternate evaluator can respond to the operation.
 26. Thesystem of claim 25, wherein the directory service operation is handledby a directory service conforming to X.500 standards.
 27. The system ofclaim 26, wherein the directory service utilizes DSML communicationsprotocols.
 28. The system of claim 26, wherein the directory serviceutilizes LDAP communications protocols.
 29. The system of claim 25,wherein the directory service operation is a query.
 30. The system ofclaim 29, wherein the query is any directory query.
 31. The system ofclaim 29, wherein the query is any directory sub-query such asNavigation.
 32. The system of claim 25, wherein determining whether analternate evaluator can respond to the operation is based on content ofthe operation.
 33. The system of claim 25, wherein evaluating theoperation using the alternate evaluator comprises generating a responseto the operation.
 34. The system of claim 25, further comprising aprimary evaluator for evaluating the operation when it is determinedthat the alternate evaluator cannot respond to the operation.
 35. Thesystem of claim 34, wherein the primary evaluator generates a responseto the operation when it is determined that the alternate evaluatorcannot respond to the operation.
 36. The system of claim 34, wherein theprimary evaluator accesses information stored on a disk in evaluatingthe operation.
 37. The system of claim 25, wherein the switch uses localconfigurations to determine whether the alternate evaluator can respondto the operation.
 38. The system of claim 25, wherein the switch usesthe alternate evaluator to determine whether the alternate evaluator canrespond to the operation.
 39. The system of claim 25, wherein logic isused in determining whether the alternate evaluator can respond to theoperation.
 40. The system of claim 25, wherein evaluating the operationusing the alternate evaluator is faster than evaluating the operationusing a primary evaluator.
 41. The system of claim 25, whereinevaluating the operation using the alternate evaluator involves fewerprocessing layers than evaluating the operation using a primaryevaluator.
 42. The system of claim 25, wherein the alternate evaluatorevaluates the operation using data that is stored locally to thealternate evaluator.
 43. The system of claim 42, wherein the data thatis stored locally comprises a local data store.
 44. The system of claim25, wherein determining whether the alternate evaluator can respond tothe operation comprises categorizing the operation according to one ormore known operation types.
 45. The system of claim 25, whereindetermining whether the alternate evaluator can respond to the operationcomprises recognizing content of the operation.
 46. The system of claim25, wherein two or more alternate evaluators are used to evaluate one ormore operations at various stages of a data path of processing layers.47. The system of claim 46, wherein one or more switches are used indetermining whether the two or more alternate evaluator can respond tothe operations.
 48. The system of claim 25, wherein the switch iscomprised of hardware.
 49. The system of claim 25, wherein the switch iscomprised of software.
 50. A computer system comprising: a processor;and a computer recording medium including computer executable codereadable by the computer system, embodying a program of instructionsexecutable by the processor for handling a directory service operation,the computer executable code comprising: determining whether analternate evaluator can respond to the operation; and evaluating theoperation using the alternate evaluator when it is determined that thealternate evaluator can respond to the operation.
 51. (canceled) 52.(canceled)
 53. (canceled)
 54. (canceled)
 55. (canceled)
 56. (canceled)57. (canceled)
 58. (canceled)
 59. (canceled)
 60. (canceled) 61.(canceled)
 62. (canceled)
 63. (canceled)
 64. (canceled)
 65. (canceled)66. (canceled)
 67. (canceled)
 68. (canceled)
 69. (canceled) 70.(canceled)
 71. (canceled)
 72. (canceled)
 73. (canceled)
 74. A computerrecording medium including computer executable code for handling adirectory service operation, the computer executable code comprising:determining whether an alternate evaluator can respond to the operation;and evaluating the operation using the alternate evaluator when it isdetermined that the alternate evaluator can respond to the operation.75. (canceled)
 76. (canceled)
 77. (canceled)
 78. (canceled) 79.(canceled)
 80. (canceled)
 81. (canceled)
 82. (canceled)
 83. (canceled)84. (canceled)
 85. (canceled)
 86. (canceled)
 87. (canceled) 88.(canceled)
 89. (canceled)
 90. (canceled)
 91. (canceled)
 92. (canceled)93. (canceled)
 94. (canceled)
 95. (canceled)
 96. (canceled) 97.(canceled)
 98. A method of processing a Directory operation in adirectory system comprising a disk based evaluator and an alternateevaluator, the method comprising the step of: examining the query todetermine if it can be processed by the alternate evaluator.
 99. Amethod as claimed in claim 98, further comprising the step of:redirecting the query to the alternate evaluator.
 100. A method asclaimed in claim 98, further comprising the step of: repeatedlyexamining the query at a number of points along a mainline path prior toevaluation by the disk based evaluator.
 101. A method as claimed inclaim 98, wherein the query is any LDAP or DSML directory query.
 102. Amethod as claimed in claim 98, wherein the query is any X.500 directoryquery.
 103. A method as claimed in claim 98, wherein the query is anydirectory sub-query such as Navigation.
 104. A method as claimed inclaim 98, wherein the step of examining the query is external and basedon the content of the query.
 105. A method as claimed in claim 98,wherein the criterion for examination is configurable.
 106. (canceled)107. (canceled)
 108. (canceled)
 109. (canceled)
 110. (canceled) 111.(canceled)
 112. (canceled)
 113. (canceled)
 114. (canceled) 115.(canceled)
 116. (canceled)
 117. (canceled)
 118. (canceled) 119.(canceled)
 120. (canceled)
 121. (canceled)
 122. (canceled)